/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package feuerwehr;

import java.math.BigDecimal;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JCheckBox;
import javax.swing.JOptionPane;
import javax.swing.JTextField;

/**
 *
 * @author GundlaPe
 */
public class Einsatz {

    public Einsatz(Integer pk, String einsatznr, String meldender, String erreichbar, Timestamp beginn, Timestamp ende, String einsatz_str, String einsatz_plz, String einsatz_ort,
                   String geschaedigt, String kostenpfltg, Integer pers_gerettet, Integer pers_geborgen, Number schaden_hoehe, Number schaden_gerettet,
                   String kz_bearbeitung, Integer fk_person, Person bearbeiter, Integer fk_stichwort, Stichwort stichwort, ArrayList kraefte_eing, 
                   ArrayList kraefte_bereit, ArrayList kraefte_frei, ArrayList kraefte_leitend, List<Detail> detail, String longitude, String latitude, String einsatzleiter_txt) {
        this.pk = pk;
        this.einsatznr = einsatznr;
        this.meldender = meldender;
        this.erreichbar = erreichbar;
        this.beginn = beginn;
        this.ende = ende;
        this.einsatz_str = einsatz_str;
        this.einsatz_plz = einsatz_plz;
        this.einsatz_ort = einsatz_ort;
        this.geschaedigt = geschaedigt;
        this.kostenpfltg = kostenpfltg;
        this.pers_gerettet = pers_gerettet;
        this.pers_geborgen = pers_geborgen;   
        this.schaden_hoehe = schaden_hoehe;   
        this.schaden_gerettet = schaden_gerettet; 
        this.kz_bearbeitung = kz_bearbeitung;
        this.fk_person = fk_person;
        this.bearbeiter = bearbeiter;
        this.fk_stichwort = fk_stichwort;
        this.stichwort = stichwort;
        this.kraefte_eing = kraefte_eing;
        this.kraefte_bereit = kraefte_bereit;        
        this.kraefte_frei = kraefte_frei;        
        this.kraefte_leitend = kraefte_leitend;        
        this.detail = detail;  
        this.longitude = longitude;
        this.latitude = latitude;
        this.einsatzleiter_txt = einsatzleiter_txt;
    }
   
    /**
     * Den letzten auto_increment Wert zurückgegeb.
     * @return Der PK
     * @throws SQLException 
     */
    private static int getLastPK() throws SQLException {
        int iPK = -1;
        PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select last_insert_id()");
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            iPK = rs.getInt(1);
        }
        rs.close();
        ps.close();
        return iPK;
    }
    
    /**
     * Einen Einsatz einlesen
     * @param iPK Der Einsatz-PK
     * @return Einsatz
     */
    public static Einsatz getEinsatz(int iPK) {
        Einsatz e = null;
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select * from t_einsatz where pk = ?");
            ps.setInt(1, iPK);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                Integer lpk = rs.getInt("pk");
                String leinsatznr = rs.getString("einsatznr");
                String lmeldender = rs.getString("meldender");
                String lerreichbar = rs.getString("erreichbar");
                Timestamp lbeginn = rs.getTimestamp("beginn");
                Timestamp lende = rs.getTimestamp("ende");
                String leinsatz_str = rs.getString("einsatz_str");
                String leinsatz_plz = rs.getString("einsatz_plz");
                String leinsatz_ort = rs.getString("einsatz_ort");
                String llongitude = rs.getString("longitude");
                String llatitude = rs.getString("latitude");
                String leinsatzleiter_txt = rs.getString("einsatzleiter_txt");
                String lgeschaedigt = rs.getString("geschaedigt");
                String lkostenpfltg = rs.getString("kostenpfltg");
                Integer lpers_gerettet = rs.getInt("pers_gerettet");
                Integer lpers_geborgen = rs.getInt("pers_geborgen");
                BigDecimal lschaden_hoehe = rs.getBigDecimal("schaden_hoehe");
                BigDecimal lschaden_gerettet = rs.getBigDecimal("schaden_gerettet");
                String lkz_bearbeitung = rs.getString("kz_bearbeitung");
                Integer lfk_person = rs.getInt("fk_person");
                Person lbearbeiter = Person.getPerson(lfk_person);
                Integer lfk_stichwort = rs.getInt("fk_stichwort");
                Stichwort lstichwort = Stichwort.getStichwort(lfk_stichwort);
                ArrayList lkraefte_eing = Person.getEingesetzteKraefte(iPK);
                ArrayList lkraefte_bereit = Person.getBereiteKraefte(iPK);
                ArrayList lkraefte_frei = Person.getFreieKraefte(iPK);
                ArrayList lkraefte_leit = Person.getLeitendeKraefte(iPK);
                List<Detail> ldetail = Detail.getDetails(iPK);
                e = new Einsatz(lpk, leinsatznr, lmeldender, lerreichbar, lbeginn, lende, leinsatz_str, leinsatz_plz, leinsatz_ort,
                                lgeschaedigt, lkostenpfltg, lpers_gerettet, lpers_geborgen, lschaden_hoehe, lschaden_gerettet,
                                lkz_bearbeitung, lfk_person, lbearbeiter, lfk_stichwort, lstichwort, lkraefte_eing, lkraefte_bereit, lkraefte_frei, 
                                lkraefte_leit, ldetail, llongitude, llatitude, leinsatzleiter_txt);
            }
            rs.close();
            ps.close();
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz Get]: " + exc.toString());
        }
        return e;
    }
     
    /**
     * Versuchen einen Einsatz zu locken. 
     * @param iPK Der Einsatz-PK
     * @return boolean Konnte der Einsatz gelockt werden?
     */
    public static boolean lockEinsatz(int iPK) {
        String lkz_bearbeitung = "N";
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select kz_bearbeitung from t_einsatz where pk = ? for update");
            ps.setInt(1, iPK);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                lkz_bearbeitung = rs.getString("kz_bearbeitung");
            }
            rs.close();
            ps.close();
            if ((lkz_bearbeitung != null) && lkz_bearbeitung.equals("J")) {
                return false;
            }
            
            ps = Feuerwehr.getConnection().prepareStatement("update t_einsatz set kz_bearbeitung = 'J', fk_person = ? where pk = ?");
            ps.setString(1, Feuerwehr.getBenutzer().getPK());
            ps.setInt(2, iPK);
            ps.executeUpdate();
            ps.close();
            // Feuerwehr.getConnection().commit();
            
            ps = Feuerwehr.getConnection().prepareStatement("select kz_bearbeitung from t_einsatz where pk = ? for update");
            ps.setInt(1, iPK);
            rs = ps.executeQuery();
            while (rs.next()) {
                lkz_bearbeitung = rs.getString("kz_bearbeitung");
            }
            rs.close();
            ps.close();
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz L]: " + exc.toString());
        }
        return true;
    }

    /**
     * Einsatz freigeben, d.h. kz_bearbeitung auf 'N' setzen
     * @param iPK Der Einsatz-PK
     * @return 
     */
    public static boolean releaseEinsatz(int iPK) {
        String lkz_bearbeitung = "N";
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select kz_bearbeitung from t_einsatz where pk = ? for update");
            ps.setInt(1, iPK);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                lkz_bearbeitung = rs.getString("kz_bearbeitung");
            }
            rs.close();
            ps.close();
            if ((lkz_bearbeitung != null) && lkz_bearbeitung.equals("N")) {
                return false;
            }
            
            ps = Feuerwehr.getConnection().prepareStatement("update t_einsatz set kz_bearbeitung = 'N' where pk = ?");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();
            // Feuerwehr.getConnection().commit();
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz RL]: " + exc.toString());
        }
        return true;
    }
    
    /**
     * Einsatz löschen wenn er "Neu" war.
     * @param iPK Der Einsatz-PK
     * @return 
     */
    public static boolean deleteEinsatz(int iPK) {
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("delete from t_e_fahrzeug where fk_einsatz = ?");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();

            ps = Feuerwehr.getConnection().prepareStatement("delete from t_einsatz where pk = ?");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();
            // Feuerwehr.getConnection().commit();
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz DL]: " + exc.toString());
        }
        return true;
    }

    /**
     * Einen neuen t_einsatz Datensatz erzeugen. Erst Sequence ziehen, dann insert into t_einsatz und anschliessend getEinsatz aufrufen.
     * @return int Der neu erzeugte EinsatzPK
     */
    public static int createEinsatz() {
        int iPK = -1;
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("insert into t_einsatz (kz_bearbeitung, fk_person) values ('J', ?)");
            ps.setString(1, Feuerwehr.getBenutzer().getPK());
            ps.executeUpdate();
            ps.close();
            
            iPK = getLastPK();
            // Feuerwehr.getConnection().commit();
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz CE]: " + exc.toString());
        }
        return iPK;
    }
    
    public static boolean writeEinsatz(int iPK, String einsatznr, String meldender, String erreichbar, String beginn, String ende, String einsatz_str, String einsatz_plz,
            String einsatz_ort, String geschaedigt, String kostenpfltg, String pers_gerettet, String pers_geborgen, String schaden_hoehe, String schaden_gerettet,
            List<Person> eingesetzt, List<Person> bereit, List<Person> chef, String alarmierung, String einsatzart,
            JCheckBox[] jcb, JTextField[] jtfAus, JTextField[] jtfEin, Stichwort stichwort, Detail detail, String longitude, String latitude, String einsatzleiter_txt) {
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("update t_einsatz set einsatznr=?, meldender=?, erreichbar=?, beginn=?, ende=?, einsatz_str=?, einsatz_plz=?, einsatz_ort=?, " +
                                       "geschaedigt=?, kostenpfltg=?, pers_gerettet=?, pers_geborgen=?, schaden_hoehe=?, schaden_gerettet=?, " +
                                       "kz_bearbeitung=?, fk_stichwort=?, longitude=?, latitude=?, einsatzleiter_txt=? where pk=?");
            ps.setString(1, einsatznr);
            ps.setString(2, meldender);
            ps.setString(3, erreichbar);
            ps.setTimestamp(4, getSQLDateFromString(beginn, "dd.MM.yyyy HH:mm:ss"));
            ps.setTimestamp(5, getSQLDateFromString(ende, "dd.MM.yyyy HH:mm:ss"));
            ps.setString(6, einsatz_str);
            ps.setString(7, einsatz_plz);
            ps.setString(8, einsatz_ort);
            ps.setString(9, geschaedigt);
            ps.setString(10, kostenpfltg);
            ps.setString(11, pers_gerettet);
            ps.setString(12, pers_geborgen);
            ps.setBigDecimal(13, new BigDecimal(schaden_hoehe));
            ps.setBigDecimal(14, new BigDecimal(schaden_gerettet));
            ps.setString(15, "N");
            ps.setString(16, stichwort.getPK());
            ps.setString(17, longitude);
            ps.setString(18, latitude);
            ps.setString(19, einsatzleiter_txt);
            ps.setInt(20, iPK);
            ps.executeUpdate();
            ps.close();
            personenUpdate(iPK, eingesetzt, "kz_aktiv");
            personenUpdate(iPK, bereit, "kz_bereit");
            personenUpdate(iPK, chef, "kz_einsatzleiter");
            alarmierungUpdate(iPK, alarmierung);
            einsatzartUpdate(iPK, einsatzart);
            fahrzeugUpdate(iPK, jcb, jtfAus, jtfEin);
            if (detail != null) {
                detailUpdate(iPK, detail);
            }
            // Feuerwehr.getConnection().commit();
            sequenceUpdate(iPK);
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz WE]: " + exc.toString());
            JOptionPane.showMessageDialog(null, "Es ist ein SQL-Fehler aufgetreten:\r\n" + exc.toString() + "\r\nBitte Elvers informieren!", Feuerwehr.STR_VERSION, JOptionPane.ERROR_MESSAGE);
            return false;
        } catch (Exception exc) {
            System.err.println("ERROR[Einsatz A]: " + exc.toString());
            JOptionPane.showMessageDialog(null, "Es ist ein allgemeiner Fehler aufgetreten:\r\n" + exc.toString() + "\r\nBitte Elvers informieren!", Feuerwehr.STR_VERSION, JOptionPane.ERROR_MESSAGE);
            return false;
        }
        return true;
    }

    /**
     * Für den Einsatz einen neuen Sequence Datensatz erstellen.
     * @param iPK Der EinsatzPK
     * @throws SQLException 
     */
    private static void sequenceUpdate(int iPK) throws SQLException {
        PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("insert into t_sequence (fk_person, fk_einsatz, datum) values (?, ?, sysdate())");
        ps.setInt(1, Integer.parseInt(Feuerwehr.getBenutzer().getPK()));
        ps.setInt(2, iPK);
        ps.executeUpdate();
        // Feuerwehr.getConnection().commit();
        ps.close();
    }

    /**
     * Die höchste Sequence ermitteln. 
     * @return Die höchste Sequence
     */
    public static int getSequence() {
        int iPK = -1;
        try {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select max(pk) from t_sequence");
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                iPK = rs.getInt(1);
            }
            rs.close();
            ps.close(); 
        } catch (SQLException exc) {
            System.err.println("ERROR[Einsatz: getSeq]: " + exc.toString());
        }            
        return iPK;
    }

    /**
     * Die Tabelle t_e_fahrzeug updaten.
     * @param iPK Der EinsatzPK
     * @param jcb JCheckBox-Array mit Fahrzeugen
     * @param jtfAus JTextField-Array mit Ausrückzeiten
     * @param jtfEin JTextField-Array mit Einrückzeiten
     * @throws SQLException 
     */
    private static void fahrzeugUpdate(int iPK, JCheckBox[] jcb, JTextField[] jtfAus, JTextField[] jtfEin) throws SQLException {
        String fahrzeug = "";
        for (int i=0; i<AnzeigeEinsatz.STA_FAHRZEUG; i++) {
            if (true == jcb[i].isSelected()) {
                fahrzeug = fahrzeug + jcb[i].getName()+ ",";
            }
        }
        if (fahrzeug.length() != 0) {
            fahrzeug = fahrzeug.substring(0, fahrzeug.length()-1);
        } else {
            fahrzeug = "'-1'";
        }
        System.err.println("DEBUG> FahrzeugPK's: " + fahrzeug);
        
        PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("delete from t_e_fahrzeug where fk_einsatz = ? and fk_fahrzeug not in (" + 
                                                     "select pk from t_fahrzeug where pk in (" + fahrzeug + "))");
        ps.setInt(1, iPK);
        ps.executeUpdate();
        ps.close();

        ps = Feuerwehr.getConnection().prepareStatement("insert into t_e_fahrzeug (fk_einsatz, fk_fahrzeug) " +
                                   "select " + iPK + ", pk from t_fahrzeug " +
                                   "where pk not in (select fk_fahrzeug from t_e_fahrzeug where fk_einsatz=? " + 
                                   "and fk_fahrzeug in (select pk from t_fahrzeug where pk in (" + fahrzeug + "))) " +
                                   "and pk in (select pk from t_fahrzeug where pk in (" + fahrzeug + "))");
        ps.setInt(1, iPK);
        ps.executeUpdate();
        ps.close();
        
        for (int i=0; i<AnzeigeEinsatz.STA_FAHRZEUG; i++) {
            if (jcb[i].isSelected() == true) {
                ps = Feuerwehr.getConnection().prepareStatement("update t_e_fahrzeug set ausrueckzeit=?, einrueckzeit=? where fk_einsatz=? and fk_fahrzeug = (select pk from t_fahrzeug where pk=?)");
                ps.setTimestamp(1, getSQLDateFromString(jtfAus[i].getText(), "dd.MM.yyyy HH:mm:ss"));
                ps.setTimestamp(2, getSQLDateFromString(jtfEin[i].getText(), "dd.MM.yyyy HH:mm:ss"));
                ps.setInt(3, iPK);
                ps.setString(4, jcb[i].getName());
                ps.executeUpdate();
            }
        }
    }
    
    /**
     * Die Tabelle t_e_einsatzart updaten.
     * @param iPK Der EinsatzPK
     * @param einsatzart String mit den Bezeichnungen
     * @throws SQLException 
     */
    private static void einsatzartUpdate(int iPK, String einsatzart) throws SQLException {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("delete from t_e_einsatzart where fk_einsatz = ? and fk_einsatzart not in (" + 
                                                         "select pk from t_einsatzart where bezeichnung in (" + einsatzart + "))");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();

            ps = Feuerwehr.getConnection().prepareStatement("insert into t_e_einsatzart (fk_einsatz, fk_einsatzart) " +
                                       "select " + iPK + ", pk from t_einsatzart " +
                                       "where pk not in (select fk_einsatzart from t_e_einsatzart where fk_einsatz=? " + 
                                       "and fk_einsatzart in (select pk from t_einsatzart where bezeichnung in (" + einsatzart + "))) " +
                                       "and pk in (select pk from t_einsatzart where bezeichnung in (" + einsatzart + "))");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();
    }

    /**
     * Die Tabelle t_e_alarmierung updaten.
     * @param iPK Der EinsatzPK
     * @param alarmierung String mit den Bezeichnungen
     * @throws SQLException 
     */
    private static void alarmierungUpdate(int iPK, String alarmierung) throws SQLException {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("delete from t_e_alarmierung where fk_einsatz = ? and fk_alarmierung not in (" + 
                                                         "select pk from t_alarmierung where bezeichnung in (" + alarmierung + "))");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();

            ps = Feuerwehr.getConnection().prepareStatement("insert into t_e_alarmierung (fk_einsatz, fk_alarmierung) " +
                                       "select " + iPK + ", pk from t_alarmierung " +
                                       "where pk not in (select fk_alarmierung from t_e_alarmierung where fk_einsatz=? " + 
                                       "and fk_alarmierung in (select pk from t_alarmierung where bezeichnung in (" + alarmierung + "))) " +
                                       "and pk in (select pk from t_alarmierung where bezeichnung in (" + alarmierung + "))");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();
    }
    
    /**
     * Die Tabelle t_e_personen ändern.
     * @param iPK Der EinsatzPK
     * @param personen Eine Liste mit den Personen
     * @param art KZ_AKTIV, KZ_BEREIT oder KZ_EINSATZLEITER
     * @throws SQLException 
     */
    private static void personenUpdate(int iPK, List<Person> personen, String art) throws SQLException {
            String s = "";
            for (Person p : personen) {
                s = s + p.getPK() + ",";
            }
            if (s.length() != 0) {
                s = s.substring(0, s.length()-1);
            } else {
                s="-1";
            }
            
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("delete from t_e_person where fk_einsatz = ? and " + art + " = 'J' and fk_person not in (" + s + ")");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();

            ps = Feuerwehr.getConnection().prepareStatement("insert into t_e_person (fk_einsatz, fk_person, " + art + ") " +
                                       "select " + iPK + ", pk, 'J' from t_person " +
                                       "where pk not in (select fk_person from t_e_person where fk_einsatz=? and " + art + " = 'J' and fk_person in (" + s +")) " +
                                       "and pk in (" + s +")");
            ps.setInt(1, iPK);
            ps.executeUpdate();
            ps.close();
            
            if (art.equals("kz_aktiv")) {
                for (Person p : personen) {
                    if (p.getAGT() != null) {
                        ps = Feuerwehr.getConnection().prepareStatement("update t_e_person set agt = ? where fk_einsatz=? and fk_person=? and kz_aktiv='J'");
                        ps.setTimestamp(1, getSQLDateFromString(p.getAGT(), "HH:mm"));
                        ps.setInt(2, iPK);
                        ps.setString(3, p.getPK());
                        ps.executeUpdate();
                    }
                }
            }
    }

    /**
     * Einen Detailsatz erstellen.
     * @param iPK Der EinsatzPK
     * @param detail Eine Liste mit den Details
     * @throws SQLException 
     */
    private static void detailUpdate(int iPK, Detail detail) throws SQLException {
        // String s1, s2;
        PreparedStatement ps2 = Feuerwehr.getConnection().prepareStatement("insert into t_e_details (datum, fk_person, fk_einsatz, detail) values (?, ?, ?, ?)");
        ps2.setTimestamp(1, getSQLDateFromString(detail.getDatum(), "dd.MM.yyyy HH:mm:ss"));
        ps2.setString(2, ((Person) detail.getPerson()).getPK());
        ps2.setInt(3, iPK);
        ps2.setString(4, detail.getDetail());
        ps2.executeUpdate();
        ps2.close();

                /*        for (Detail d : detail) {
            PreparedStatement ps = Feuerwehr.getConnection().prepareStatement("select '1', detail from t_e_details where pk = ?");      // Haben wir den Datensatz schon?
            ps.setString(1, d.getPK());
            ResultSet rs = ps.executeQuery();
            s1 = "";
            s2 = "";
            while (rs.next()) {
                s1 = rs.getString(1);
                s2 = rs.getString(2);
            }
            rs.close();
            ps.close();
            System.err.println("DEBUG>> Detail Inhalt: " + d.getDetail());
            if (s1.equals("1")) {                                                                       // Update
                if (!s2.equals(d.getDetail())) {
                    System.err.println("DEBUG>> Detail update tatsächlich");
                    PreparedStatement ps2 = Feuerwehr.getConnection().prepareStatement("update t_e_details set datum=?, fk_person=?, detail=? where pk=?");
                    ps2.setTimestamp(1, getSQLDateFromString(d.getDatum(), "dd.MM.yyyy HH:mm:ss"));
                    ps2.setString(2, ((Person)d.getPerson()).getPK());
                    ps2.setString(3, d.getDetail());
                    ps2.setString(4, d.getPK());
                    ps2.executeUpdate();
                    ps2.close();
                } else
                    System.err.println("DEBUG>> Detail update abgebrochen");
            } else {                                                                                    // Insert
                System.err.println("DEBUG>> Detail insert");
                PreparedStatement ps2 = Feuerwehr.getConnection().prepareStatement("insert into t_e_details (datum, fk_person, fk_einsatz, detail) values (?, ?, ?, ?)");
                ps2.setTimestamp(1, getSQLDateFromString(d.getDatum(), "dd.MM.yyyy HH:mm:ss"));
                ps2.setString(2, ((Person)d.getPerson()).getPK());
                ps2.setInt(3, iPK);
                ps2.setString(4, d.getDetail());
                ps2.executeUpdate();
                ps2.close();
            }
        }
*/        
    }
    
    /**
     * Einen String in ein java.sql.Timestamp ändern
     * @param value Der String mit dem Datum
     * @param format Ein gültiges Format für SimpleDateFormat
     * @return Das java.sql.Timestamp
     */
    public static Timestamp getSQLDateFromString(String value, String format) {
        SimpleDateFormat formatter = new SimpleDateFormat(format);
        Timestamp sqlDate = null;
        if (!value.equals("")) {
            try {
                sqlDate = new java.sql.Timestamp(formatter.parse(value).getTime());
                // DateFormat df = DateFormat.getDateTimeInstance();
            } catch (ParseException exc) {
                JOptionPane.showMessageDialog(null, "Ungültiges Datum <" + value + "> für Format <"+ format + ">!", Feuerwehr.STR_VERSION, JOptionPane.ERROR_MESSAGE);
            }
        }
        return sqlDate;
    }
    
    public int getPK() {
        return pk;
    }

    public String getEinsatzleiter() {
        if (einsatzleiter_txt==null)
            return "";
        return einsatzleiter_txt;
    }

    public String getEinsatznr() {
        if (einsatznr==null)
            return "";
        return einsatznr;
    }

    public String getMeldender() {
        if (meldender==null)
            return "";
        return meldender;
    }

    public String getErreichbar() {
        if (erreichbar==null)
            return "";
        return erreichbar;
    }
    
    public String getEinsatzOrt() {
        if (einsatz_ort==null)
            return "";
        return einsatz_ort;
    }

    public String getEinsatzStr() {
        if (einsatz_str==null)
            return "";
        return einsatz_str;
    }
    
    public String getEinsatzPLZ() {
        if (einsatz_plz==null)
            return "";
        return einsatz_plz;
    }

    public String getBeginn() {
        if (beginn == null)
            return "";
        return Feuerwehr.formatDatum(beginn, "dd.MM.yyyy HH:mm:ss");
    }
    
    public String getEnde() {
        if (ende == null)
            return "";
        return Feuerwehr.formatDatum(ende, "dd.MM.yyyy HH:mm:ss");
    }

    public String getGeschaedigt() {
        if (einsatznr==null)
            return "";
        return geschaedigt;
    }

    public String getKostenpfltg() {
        if (kostenpfltg == null)
            return "";
        return kostenpfltg;
    }

    public String getPers_gerettet() {
        return Integer.toString(pers_gerettet);
    }

    public String getPers_geborgen() {
        return Integer.toString(pers_geborgen);
    }
    
    public String getSchaden_hoehe() {
        if (schaden_hoehe == null)
            return "";
        return schaden_hoehe.toString();
    }
    
    public String getSchaden_gerettet() {
        if (schaden_gerettet == null)
            return "";
        return schaden_gerettet.toString();
    }

    public String getKz_bearbeitung() {
        if (kz_bearbeitung == null)
            return "";
        return kz_bearbeitung;
    }

    public Person getBearbeiter() {
        return bearbeiter;
    }

    public Integer getStichwortFK() {
        return fk_stichwort;
    }

    public Stichwort getStichwort() {
        return stichwort;
    }

    public String getLongitude() {
        if (longitude == null)
            return "";
        return longitude;
    }

    public String getLatitude() {
        if (latitude == null)
            return "";
        return latitude;
    }

    public ArrayList getKraefteEingesetzt() {
        return kraefte_eing;
    }
    
    public ArrayList getKraefteFrei() {
        return kraefte_frei;
    }
    
    public ArrayList getKraefteBereit() {
        return kraefte_bereit;
    }
    
    public ArrayList getKraefteLeitend() {
        return kraefte_leitend;
    }
    
    public List<Detail> getDetail() {
        return detail;
    }

    private final Integer pk;
    private final String einsatznr;
    private final String meldender;
    private final String erreichbar;
    private final Timestamp beginn;
    private final Timestamp ende;
    private final String einsatz_str;
    private final String einsatz_plz;
    private final String einsatz_ort;
    private final String longitude;
    private final String latitude;
    private final String einsatzleiter_txt;
    private final String geschaedigt;
    private final String kostenpfltg;
    private final Integer pers_gerettet;
    private final Integer pers_geborgen;   
    private final Number schaden_hoehe;   
    private final Number schaden_gerettet; 
    private final String kz_bearbeitung;
    private final Integer fk_person;
    private final Person bearbeiter;
    private final Integer fk_stichwort;
    private final Stichwort stichwort;
    private final ArrayList kraefte_eing;
    private final ArrayList kraefte_bereit;
    private final ArrayList kraefte_leitend;
    private final ArrayList kraefte_frei;
    private final List<Detail> detail;
}
